home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / hips / sources / isobuild / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-11  |  11.1 KB  |  487 lines
  1.  
  2. /* misc.c     Brian Tierney */
  3.  
  4. /* for use with the isobuild program:
  5.  * routines for array allocation / deallocation / initilization, etc
  6.  *
  7.  *  3d arrays are all allocated as arrays of pointer to arrays or pointers
  8.  *  to arrays of data.  This takes a bit more memory, but array element
  9.  *  access is somewhat faster because there is no additions/multiplication
  10.  *  used in the access, only indirection.  -BT
  11.  */
  12.  
  13. /* $Id: misc.c,v 1.3 1992/01/31 02:05:45 tierney Exp $ */
  14.  
  15. /* $Log: misc.c,v $
  16.  * Revision 1.3  1992/01/31  02:05:45  tierney
  17.  * y
  18.  *
  19.  * Revision 1.2  1991/12/19  01:42:20  davidr
  20.  * added RCS identification markers
  21.  * */
  22.  
  23. static char rcsid[] = "$Id: misc.c,v 1.3 1992/01/31 02:05:45 tierney Exp $" ;
  24.  
  25. #include "isobuild.h"
  26.  
  27. /**************************** get_max_min ****************************/
  28.  
  29. void
  30. get_max_min(size, max, min)
  31.     int       size;
  32.     Data_type *max, *min;
  33. /* This subroutine finds the maximum & minimum data values */
  34. {
  35.  
  36.     register int i;
  37.     register Data_type *dptr;
  38.     Data_type lmin, lmax;    /* local min and max variable */
  39.  
  40.     dptr = data[0][0];
  41.  
  42.     lmax = lmin = dptr[0];
  43.     for (i = 0; i < size; i++) {
  44.     if (dptr[i] > lmax)
  45.         lmax = dptr[i];
  46.     else if (dptr[i] < lmin)
  47.         lmin = dptr[i];
  48.     }
  49.  
  50.     *max = lmax;
  51.     *min = lmin;
  52.     return;
  53. }
  54.  
  55. /**************************************************/
  56.  
  57. Data_type ***
  58. alloc_3d_data_array(nx, ny, nz)
  59.     int       nx, ny, nz;
  60. {
  61.     register int i, j;
  62.  
  63.     Data_type ***array;
  64.  
  65.     /* allocate 3-d array for input image data */
  66.  
  67.     /* allocate 2 arrays of pointers */
  68.     if ((array = Calloc(nx, Data_type **)) == NULL)
  69.     perror("calloc error: data array ");
  70.     if ((array[0] = Calloc(nx * ny, Data_type *)) == NULL)
  71.     perror("calloc error: data array ");
  72.  
  73.     /* allocate array for data */
  74.     if ((array[0][0] = Calloc(nx * ny * nz, Data_type)) == NULL)
  75.     perror("calloc error: data array ");
  76.  
  77.     /* initialize pointer arrays */
  78.     for (i = 1; i < ny; i++)
  79.     array[0][i] = **array + (nz * i);
  80.     for (i = 1; i < nx; i++) {
  81.     array[i] = *array + (ny * i);
  82.     array[i][0] = **array + (ny * nz * i);
  83.     for (j = 1; j < ny; j++)/* initialize pointer array */
  84.         array[i][j] = array[i][0] + (nz * j);
  85.     }
  86.     return (array);
  87. }
  88.  
  89. /***********************************************************/
  90. Grid_type ***
  91. alloc_3d_grid_array(nx, ny, nz)    /* in hips terminology: col,row,frame */
  92.     int       nx, ny, nz;
  93. {
  94.     register int i, j;
  95.  
  96.     /* allocate 3-d array for grid  */
  97.  
  98.     Grid_type ***array;
  99.  
  100.     /* allocate 2 arrays of pointers */
  101.     if ((array = Calloc(nx, Grid_type **)) == NULL)
  102.     perror("calloc error: grid array ");
  103.     if ((array[0] = Calloc(nx * ny, Grid_type *)) == NULL)
  104.     perror("calloc error: grid array ");
  105.  
  106.     /* allocate array for data */
  107.     if ((array[0][0] = Calloc(nx * ny * nz, Grid_type)) == NULL)
  108.     perror("calloc error: grid array ");
  109.  
  110.     /* initialize pointer arrays */
  111.     for (i = 1; i < ny; i++)
  112.     array[0][i] = **array + (nz * i);
  113.     for (i = 1; i < nx; i++) {
  114.     array[i] = *array + (ny * i);
  115.     array[i][0] = **array + (nz * ny * i);
  116.     for (j = 1; j < ny; j++)/* initialize pointer array */
  117.         array[i][j] = array[i][0] + (nz * j);
  118.     }
  119.     return (array);
  120.  
  121. }
  122.  
  123. /***********************************************************/
  124. NORMAL_VECT ***
  125. alloc_3d_normal_array(nx, ny, nz)    /* in hips terminology: col,row,frame */
  126.     int       nx, ny, nz;
  127. {
  128.     register int i, j;
  129.  
  130.     NORMAL_VECT ***array;
  131.  
  132.     /* allocate 3-d array for array  */
  133.  
  134.     /* allocate 2 arrays of pointers */
  135.     if ((array = Calloc(nx, NORMAL_VECT **)) == NULL)
  136.     perror("calloc error: norm array ");
  137.     if ((array[0] = Calloc(nx * ny, NORMAL_VECT *)) == NULL)
  138.     perror("calloc error: norm array ");
  139.  
  140.     /* allocate array for data */
  141.     if ((array[0][0] = Calloc(nx * ny * nz, NORMAL_VECT)) == NULL)
  142.     perror("calloc error: norm array ");
  143.  
  144.     /* initialize pointer arrays */
  145.     for (i = 1; i < ny; i++)
  146.     array[0][i] = **array + (nz * i);
  147.     for (i = 1; i < nx; i++) {
  148.     array[i] = *array + (ny * i);
  149.     array[i][0] = **array + (nz * ny * i);
  150.     for (j = 1; j < ny; j++)/* initialize pointer array */
  151.         array[i][j] = array[i][0] + (nz * j);
  152.     }
  153.     return (array);
  154.  
  155. }
  156. /***********************************************************/
  157. NORMAL_VECT **
  158. alloc_2d_normal_array(nx, ny)    /* in hips terminology: col,row,frame */
  159.     int       nx, ny;
  160. {
  161.     register int i;
  162.  
  163.     NORMAL_VECT **array;
  164.  
  165.     /* allocate array of pointers */
  166.     if ((array = Calloc(nx, NORMAL_VECT *)) == NULL)
  167.     perror("calloc error: 2d normal array ");
  168.  
  169.     /* allocate array for data */
  170.     if ((array[0] = Calloc(nx * ny, NORMAL_VECT)) == NULL)
  171.     perror("calloc error: 2d normal array ");
  172.  
  173.     /* initialize pointer arrays */
  174.     for (i = 0; i < nx; i++)
  175.     array[i] = *array + (ny * i);
  176.  
  177.     return (array);
  178. }
  179.  
  180. /***********************************************************/
  181. FLOAT_VECT **
  182. alloc_2d_vector_array(nx, ny)    /* in hips terminology: col,row,frame */
  183.     int       nx, ny;
  184. {
  185.     register int i;
  186.  
  187.     FLOAT_VECT **array;
  188.  
  189.     /* allocate array of pointers */
  190.     if ((array = Calloc(nx, FLOAT_VECT *)) == NULL)
  191.     perror("calloc error: 2d vector array ");
  192.  
  193.     /* allocate array for data */
  194.     if ((array[0] = Calloc(nx * ny, FLOAT_VECT)) == NULL)
  195.     perror("calloc error: 2d vector array ");
  196.  
  197.     /* initialize pointer arrays */
  198.     for (i = 0; i < nx; i++)
  199.     array[i] = *array + (ny * i);
  200.  
  201.     return (array);
  202. }
  203.  
  204. /**********************************/
  205. Data_type **
  206. alloc_2d_data_array(nx, ny)
  207.     int       nx, ny;
  208. {
  209.     Data_type **array;
  210.     register int i;
  211.  
  212.     /* allocate 2-d array for input image data */
  213.     /* allocate array of pointers */
  214.     if ((array = Calloc(nx, Data_type *)) == NULL)
  215.     perror("calloc error: 2d data array ");
  216.  
  217.     /* allocate array for data */
  218.     if ((array[0] = Calloc(nx * ny, Data_type)) == NULL)
  219.     perror("calloc error: 2d data array ");
  220.  
  221.     /* initialize pointer arrays */
  222.     for (i = 0; i < nx; i++)
  223.     array[i] = *array + (ny * i);
  224.  
  225.     return (array);
  226. }
  227.  
  228. /*********************************************************/
  229. CUBE_TRIANGLES **
  230. alloc_2d_cube_array(nx, ny)
  231.     int       nx, ny;
  232. {
  233.     CUBE_TRIANGLES **array;
  234.     register int i;
  235.  
  236.     /* allocate 2-d array for input image data */
  237.     /* allocate array of pointers */
  238.     if ((array = Calloc(nx, CUBE_TRIANGLES *)) == NULL)
  239.     perror("calloc error: cube array ");
  240.  
  241.     /* allocate array for data */
  242.     if ((array[0] = Calloc(nx * ny, CUBE_TRIANGLES)) == NULL)
  243.     perror("calloc error: cube array ");
  244.  
  245.     /* initialize pointer arrays */
  246.     for (i = 1; i < nx; i++)
  247.     array[i] = array[0] + (ny * i);
  248.  
  249.     return (array);
  250. }
  251.  
  252. /**********************************/
  253. Grid_type **
  254. alloc_2d_grid_array(nx, ny)
  255.     int       nx, ny;
  256. {
  257.     Grid_type **array;
  258.     register int i;
  259.  
  260.     /* allocate 2-d array for input image data */
  261.     /* allocate array of pointers */
  262.     if ((array = Calloc(nx, Grid_type *)) == NULL)
  263.     perror("calloc error: array ");
  264.  
  265.     /* allocate array for data */
  266.     if ((array[0] = Calloc(nx * ny, Grid_type)) == NULL)
  267.     perror("calloc error: array ");
  268.  
  269.     /* initialize pointer arrays */
  270.     for (i = 0; i < nx; i++)
  271.     array[i] = *array + (ny * i);
  272.  
  273.     return (array);
  274. }
  275.  
  276. /**********************************/
  277. BLOCK_INFO **
  278. alloc_block_info_array(nx, ny)
  279.     int       nx, ny;
  280. {
  281.     BLOCK_INFO **array;
  282.     register int i;
  283.  
  284.     /* allocate 2-d array for input image data */
  285.     /* allocate array of pointers */
  286.     if ((array = Calloc(nx, BLOCK_INFO *)) == NULL)
  287.     perror("calloc error: array ");
  288.  
  289.     /* allocate array for data */
  290.     if ((array[0] = Calloc(nx * ny, BLOCK_INFO)) == NULL)
  291.     perror("calloc error: array ");
  292.  
  293.     /* initialize pointer arrays */
  294.     for (i = 0; i < nx; i++)
  295.     array[i] = *array + (ny * i);
  296.  
  297.     return (array);
  298. }
  299.  
  300. /********************************/
  301. int
  302. free_block_info_array(array)
  303.     BLOCK_INFO **array;
  304. {
  305. #ifdef CRAY
  306.     cfree((char *) array[0],NULL,NULL);
  307.     cfree((char *) array,NULL,NULL);
  308. #else
  309.     cfree((char *) array[0]);
  310.     cfree((char *) array);
  311. #endif
  312. }
  313.  
  314. /********************************/
  315. int
  316. free_3d_data_array(array)
  317.     Data_type ***array;
  318. {
  319. #ifdef CRAY
  320.     cfree((char *) array[0][0],NULL,NULL);
  321.     cfree((char *) array[0],NULL,NULL);
  322.     cfree((char *) array,NULL,NULL);
  323. #else
  324.     cfree((char *) array[0][0]);
  325.     cfree((char *) array[0]);
  326.     cfree((char *) array);
  327. #endif
  328. }
  329.  
  330. /********************************/
  331. int
  332. free_3d_normal_array(array)
  333.     NORMAL_VECT ***array;
  334. {
  335. #ifdef CRAY
  336.     cfree((char *) array[0][0], NULL, NULL);
  337.     cfree((char *) array[0], NULL, NULL);
  338.     cfree((char *) array, NULL, NULL);
  339. #else
  340.     cfree((char *) array[0][0]);
  341.     cfree((char *) array[0]);
  342.     cfree((char *) array);
  343. #endif
  344. }
  345. /********************************/
  346. int
  347. free_2d_normal_array(array)
  348.     NORMAL_VECT **array;
  349. {
  350. #ifdef CRAY
  351.     cfree((char *) array[0], NULL, NULL);
  352.     cfree((char *) array, NULL, NULL);
  353. #else
  354.     cfree((char *) array[0]);
  355.     cfree((char *) array);
  356. #endif
  357. }
  358. /********************************/
  359. int
  360. free_2d_vector_array(array)
  361.     FLOAT_VECT **array;
  362. {
  363. #ifdef CRAY
  364.     cfree((char *) array[0], NULL, NULL);
  365.     cfree((char *) array, NULL, NULL);
  366. #else
  367.     cfree((char *) array[0]);
  368.     cfree((char *) array);
  369. #endif
  370. }
  371.  
  372. /********************************/
  373. int
  374. free_3d_grid_array(array)
  375.     Grid_type ***array;
  376. {
  377. #ifdef CRAY
  378.     cfree((char *) array[0][0], NULL, NULL);
  379.     cfree((char *) array[0], NULL, NULL);
  380.     cfree((char *) array, NULL, NULL);
  381. #else
  382.     cfree((char *) array[0][0]);
  383.     cfree((char *) array[0]);
  384.     cfree((char *) array);
  385. #endif
  386. }
  387.  
  388. /*********************************/
  389. int
  390. free_2d_data_array(array)
  391.     Data_type **array;
  392. {
  393. #ifdef CRAY
  394.     cfree((char *) array[0], NULL, NULL);
  395.     cfree((char *) array, NULL, NULL);
  396. #else
  397.     cfree((char *) array[0]);
  398.     cfree((char *) array);
  399. #endif
  400. }
  401.  
  402. /*********************************/
  403. int
  404. free_2d_cube_array(array)
  405.     CUBE_TRIANGLES **array;
  406. {
  407. #ifdef CRAY
  408.     cfree((char *) array[0], NULL, NULL);
  409.     cfree((char *) array, NULL, NULL);
  410. #else
  411.     cfree((char *) array[0]);
  412.     cfree((char *) array);
  413. #endif
  414. }
  415.  
  416. /*********************************/
  417. int
  418. free_2d_grid_array(array)
  419.     Grid_type **array;
  420. {
  421. #ifdef CRAY
  422.     cfree((char *) array[0], NULL, NULL);
  423.     cfree((char *) array, NULL, NULL);
  424. #else
  425.     cfree((char *) array[0]);
  426.     cfree((char *) array);
  427. #endif
  428. }
  429. /***************************************/
  430.  
  431. #ifdef DEBUG_SIZE
  432. get_mem_size()
  433. {
  434.     int       pid;
  435.     char      argstr[40];
  436.  
  437.     pid = getpid();
  438.  
  439.     sprintf(argstr, "show_prog_size %d", pid);
  440.  
  441.     (void) system(argstr);
  442.  
  443. #ifdef WANT
  444.     /* execlp uses the shell's path for searching for the executable */
  445.     (void) execlp("show_prog_size", "show_prog_size", arg1, NULL);
  446. #endif
  447. }
  448.  
  449. #endif
  450.  
  451. /********************************************************/
  452. init_dup_vertex_check_arrays()
  453. {
  454.     register int i,j;
  455.  
  456.     /* reset the currslice and prevslice info */
  457.     for (i=0; i< xdim; i++)
  458.     for (j=0; j< ydim; j++) {
  459.         currslice[j][i].edge_index = -1;
  460.         currslice[j][i].num_edges = 0;
  461.         prevslice[j][i].edge_index = -1;
  462.         prevslice[j][i].num_edges = 0;
  463.     }
  464. }
  465.  
  466. /***************************************************************/
  467.  
  468. void
  469. Error(mesg)
  470. char *mesg;
  471. {
  472.  
  473.     fprintf(stderr,"\n%s: Error, %s \n", MY_NAME, mesg);
  474.     exit_handler();
  475. }
  476.      
  477. /***************************************************************/
  478.  
  479. void
  480. Status(mesg)
  481. char *mesg;
  482. {
  483.     fprintf(stderr,"%s: %s \n", MY_NAME, mesg);
  484. }
  485.  
  486.  
  487.